Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@app/src/components/Generation/FloatingGenerateBox.tsx`:
- Around line 133-143: The type assertion used when setting the engine from
selectedProfile?.default_engine in the form.setValue('engine', ...) call is
missing the 'qwen_custom_voice' variant; update the union of allowed engine
string literals to include 'qwen_custom_voice' so the cast covers that value
(i.e., ensure the same union used in the setValue call includes
'qwen_custom_voice' alongside 'qwen', 'luxtts', 'chatterbox',
'chatterbox_turbo', 'tada', and 'kokoro').

In `@app/src/components/VoiceProfiles/ProfileForm.tsx`:
- Around line 490-509: When creating a preset profile in the voiceSource ===
'builtin' branch, additionally validate that the selectedPresetVoiceId actually
belongs to the currently selectedPresetEngine before calling
createProfile.mutateAsync; lookup the selected voice from whatever collection
maps voices to engines (e.g., voices list, voicesByEngine or presetVoicesMap
used elsewhere in ProfileForm) and if the voice is missing or its engine !==
selectedPresetEngine, show a destructive toast (like the existing "No voice
selected" toast) indicating the voice/engine mismatch and return early,
otherwise proceed to call createProfile.mutateAsync with the validated
selectedPresetEngine and selectedPresetVoiceId.
- Around line 441-448: The update payload currently uses default_engine:
defaultEngine || undefined which omits the field when defaultEngine is '',
preventing the backend (backend/services/profiles.py) from clearing the existing
default; change the payload in the updateProfile.mutateAsync call so that when
defaultEngine is the explicit "No preference" empty string it sends a present
null (e.g., default_engine: defaultEngine === '' ? null : defaultEngine ||
undefined) so the backend can detect the field and clear the stored
default_engine for the profile identified by editingProfileId.

In `@backend/backends/kokoro_backend.py`:
- Around line 177-191: The _get_pipeline method currently falls back to "a" for
unknown lang_code via LANG_CODE_MAP.get(lang_code, "a"), which silently routes
unsupported languages to the US English pipeline; change the logic in
_get_pipeline to first check if lang_code exists in LANG_CODE_MAP and if not
raise a clear exception (e.g., ValueError) indicating the language is
unsupported by Kokoro, otherwise map with LANG_CODE_MAP[lang_code] and proceed
to create/return the KPipeline; update any callers if they expect silent
fallback to handle the raised exception.
- Around line 216-225: The current code path that returns
{"voice_type":"preset","preset_engine":"kokoro","preset_voice_id":KOKORO_DEFAULT_VOICE},
False silently substitutes the default voice for cloned profiles and must
instead reject cloned-profile requests as unsupported; change that code (the
method that currently returns the dict + False) to detect a cloned profile and
raise or return an explicit unsupported error (e.g., raise
UnsupportedProfileError or NotImplementedError with a clear message) rather than
returning KOKORO_DEFAULT_VOICE, and ensure callers handle that error path
instead of treating the request as successful.

In `@backend/database/migrations.py`:
- Around line 185-226: The _resolve_relative_paths function currently uses
Path(path_val).resolve() which resolves against the process CWD and can produce
incorrect results in production; instead obtain the configured data directory
(e.g., from your application's config/init_db context—something like
settings.data_dir or the same source used when writing these paths) and resolve
relative entries against that directory (use Path(data_dir) / path_val or
Path(data_dir).joinpath(path_val) then .resolve()), verify that this resolved
path exists before updating via the same conn.execute(...) UPDATE used now, keep
the existing checks so absolute paths remain untouched, and ensure data_dir is
normalized to an absolute Path and handled gracefully if missing.

In `@backend/models.py`:
- Around line 18-22: Add validation to the Pydantic model so malformed
non-cloning profiles are rejected: implement validators (e.g., `@root_validator`
or `@validator` on voice_type) that (1) when voice_type == "preset" require
non-empty preset_engine and preset_voice_id, (2) when voice_type == "designed"
reject or require design_prompt only if the backend supports it (currently
reject/desist if unsupported), and (3) validate preset_engine and default_engine
against a canonical set of supported engine identifiers (use a shared
SUPPORTED_ENGINES constant or enum) instead of allowing arbitrary strings;
update the model fields voice_type, preset_engine, preset_voice_id,
design_prompt, default_engine to use these validators so invalid combinations
fail validation immediately.

In `@backend/routes/profiles.py`:
- Around line 147-156: The TOCTOU checks around DBVoiceProfile (checking
preset_engine/preset_voice_id and name with .first()) are racy; instead add a
database-level unique constraint on (preset_engine, preset_voice_id) in the
DBVoiceProfile model and stop relying on those pre-checks in the preset-seeding
route, then perform inserts and either use a DB upsert/ON CONFLICT DO NOTHING
(preferred) or catch sqlalchemy.exc.IntegrityError around the session add/commit
and ignore conflicts so the seeding becomes idempotent under concurrent
requests; apply the same change for both uniqueness checks currently guarding
name and the (preset_engine,preset_voice_id) insert logic.
- Around line 159-168: The seeded Kokoro DBVoiceProfile entries are missing
default_engine="kokoro", causing engine selection to remain set to a previous
backend; update the DBVoiceProfile construction for these Kokoro presets (the
DBVoiceProfile instantiation that sets preset_engine="kokoro" and
preset_voice_id=voice_id) to include default_engine="kokoro" so seeded profiles
explicitly set the engine. Ensure the same change is applied wherever Kokoro
preset profiles are created so selection routes to the kokoro backend.

In `@backend/services/profiles.py`:
- Around line 429-435: The preset branch blindly returns the profile's
preset_engine/preset_voice_id ignoring the requested engine; update the
voice_type == "preset" handling to check that the requested engine (engine)
matches profile.preset_engine and fail fast if it doesn't (raise a clear
exception or return an error) rather than returning the preset_voice_id to the
wrong backend; keep returning the existing dict when engines match and include a
descriptive message referencing profile.preset_engine and preset_voice_id when
rejecting the request.

---

Nitpick comments:
In `@app/src/components/VoiceProfiles/ProfileCard.tsx`:
- Around line 106-115: The badge rendering in ProfileCard (where
profile.voice_type is 'preset') can show "undefined" if profile.preset_engine is
missing; update the display logic in the ProfileCard component to safely
fallback to a friendly string (e.g., 'unknown' or 'preset') when
ENGINE_DISPLAY_NAMES[profile.preset_engine ?? ''] and profile.preset_engine are
both falsy. Locate the conditional that uses ENGINE_DISPLAY_NAMES and
profile.preset_engine and change the fallback expression so it never returns
undefined (use a final default string).

In `@app/src/lib/hooks/useGenerationForm.ts`:
- Around line 96-100: When building the model string in useGenerationForm (the
ternary that returns `qwen-custom-voice-${data.modelSize}`), guard against an
undefined modelSize by using a fallback (e.g., `data.modelSize ?? '1.7B'` or the
form's default) so the constructed name never becomes
`qwen-custom-voice-undefined`; update the branch that handles `engine ===
'qwen_custom_voice'` to interpolate that fallback value instead of
`data.modelSize` directly.

In `@backend/build_binary.py`:
- Around line 89-91: Add a short descriptive section comment above the Qwen
CustomVoice backend hidden-import lines (the entries containing
"backend.backends.qwen_custom_voice_backend" and "backend.utils.audio") to match
the style used for other backends (e.g., the Kokoro comment block). Place a
one-line comment like "# Qwen CustomVoice backend" immediately before those list
entries so maintainers can easily identify this backend group.

In `@backend/voicebox-server.spec`:
- Line 8: The single-line hiddenimports assignment is hard to read and maintain;
update the hiddenimports variable to span multiple lines as a Python list
literal (e.g., broken into several lines or grouped by category such as
backend.*, backend.services.*, external libs) while keeping the same symbol name
hiddenimports and preserving all string entries and commas so the value is
unchanged; ensure the resulting formatting is a valid Python list literal
(opening [, each entry on its own line or grouped lines, trailing comma allowed,
closing ]) so diffs are smaller and grouping/ordering (optionally alphabetical)
is easier to maintain.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@app/src/components/Generation/GenerationForm.tsx`:
- Around line 30-35: getEngineSelectValue currently maps the bare 'tada' profile
value to 'tada:1B' which forces applyEngineSelection to reset non-English
profiles to English; update getEngineSelectValue to accept the profile language
(e.g., add a second parameter like language: string | undefined) and return
'tada:1B' only when language === 'en' (or undefined) and return 'tada:3B' when
language !== 'en'; update any callers (such as where applyEngineSelection is
used) to pass the profile's language so the helper can choose the correct TADA
size and avoid overwriting the saved language.

In `@app/src/components/VoiceProfiles/ProfileForm.tsx`:
- Around line 854-859: The language Select is currently uncontrolled (uses
defaultValue={field.value}) so programmatic updates via setSelectedPresetVoiceId
and form.setValue('language', ...) don't reflect; change the Select to be
controlled by replacing defaultValue with value={field.value} and ensure its
onChange calls form.setValue('language', ...) (or use the existing Controller
render's onChange hookup) so that updates from setSelectedPresetVoiceId and
form.setValue update the visible Select value.

In `@backend/routes/generations.py`:
- Around line 23-24: The resolver _resolve_generation_engine is never seeing an
omitted engine because models.GenerationRequest.engine currently defaults to
"qwen"; change GenerationRequest.engine's default to None in backend/models.py
so omission is distinguishable and the existing resolver can fall through to
profile.default_engine / profile.preset_engine, or alternatively modify
_resolve_generation_engine to treat a special sentinel (e.g., None) as “omitted”
and only use the literal "qwen" as the final fallback after checking
profile.default_engine and profile.preset_engine; update references to
GenerationRequest.engine, _resolve_generation_engine, profile.default_engine and
profile.preset_engine accordingly.
- Around line 43-46: The ValueError raised by profiles.validate_profile_engine
is currently caught and re-raised as an HTTPException without chaining, which
loses the original exception context; update both exception handlers that catch
ValueError from profiles.validate_profile_engine to re-raise the HTTPException
using "raise HTTPException(status_code=400, detail=str(e)) from e" so the
original ValueError is preserved in the exception chain (refer to the try/except
blocks around profiles.validate_profile_engine and the HTTPException raises).

---

Duplicate comments:
In `@app/src/components/VoiceProfiles/ProfileForm.tsx`:
- Around line 476-483: The update payload currently omits default_engine when
defaultEngine is an empty string so clearing a profile's default isn't possible;
in the call to updateProfile.mutateAsync (the block using editingProfileId and
data { name, description, language, default_engine }), send an explicit clear
value instead of dropping the key — e.g. set default_engine to null when
defaultEngine === '' and otherwise to defaultEngine (default_engine:
defaultEngine === '' ? null : defaultEngine) so "No preference" clears the saved
engine.

---

Nitpick comments:
In `@app/src/components/Generation/EngineModelSelector.tsx`:
- Around line 45-50: There are duplicated, inverse hardcoded engine sets between
CLONING_ENGINES in EngineModelSelector and the profile form filter; create a
single shared source (e.g., export a constant or helper) that defines
engine<->profile compatibility and import it where needed so both
getAvailableOptions (in EngineModelSelector) and the filtering logic in
ProfileForm.tsx use the same rule; specifically, move the compatibility data
and/or a helper like isProfileCompatibleWithEngine into a new/shared module and
update references to ENGINE_OPTIONS, CLONING_ENGINES, getAvailableOptions and
the ProfileForm filtering code to call the single exported helper or use the
exported set.

In `@backend/database/migrations.py`:
- Line 37: run_migrations() currently calls _resolve_relative_paths() which
fetches all non-null path rows from multiple tables every startup; change this
so we avoid an O(total rows) scan by either gating _resolve_relative_paths()
behind a one-shot schema/version flag stored in your migrations table (so it
runs only once) or by changing the SQL in _resolve_relative_paths() to only
select candidates that are relative paths (e.g., add WHERE clauses like path NOT
LIKE '/%' or other DB-specific checks) instead of fetchall()'ing entire tables;
update the logic in _resolve_relative_paths() and any callers (run_migrations(),
and the similar code noted around the other occurrences) to use the gate or
narrowed queries and mark the migration as applied so it won't run on subsequent
startups.

In `@backend/voicebox-server.spec`:
- Line 8: Add a collect_all('kokoro') call in the spec so kokoro package
data/binaries are bundled like other backends; update the spec near the
hiddenimports list (which already includes 'kokoro', 'kokoro.pipeline',
'kokoro.model', etc.) to call collect_all('kokoro') alongside existing
collect_all calls (e.g., those for qwen_tts/misaki) so kokoro's non-Python
assets are included in the build.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@backend/backends/qwen_custom_voice_backend.py`:
- Around line 82-93: load/unload/generate currently mutate and read self.model
without synchronization causing race conditions; add a shared asyncio.Lock (or
an active-ops counter with a lock) on the backend class and use it to serialize
model swaps and protect in-flight inference: acquire the lock (or increment
active-ops) in load_model_async and unload_model around mutations to self.model
and _current_model_size, and in generate acquire the lock (or increment
active-ops) briefly to capture a stable reference to self.model into a local
variable which you then pass to _generate_sync; update _generate_sync signature
to accept the model reference so threads use the stable snapshot and ensure the
lock/active-ops is released (or decremented) appropriately to avoid deadlocks.

In `@backend/routes/generations.py`:
- Around line 23-24: Centralize engine-specific model-size fallbacks and use
them whenever engine is auto-selected: add a helper (e.g., _resolve_model_size
or extend _resolve_generation_engine to return both engine and default_size)
that maps engines ("qwen", "tada", etc.) to their correct default model_size
("1.7B" for qwen, "1B"/"3B" for tada as appropriate), then update the
routes/handlers that currently default model_size to "1.7B" (including the logic
referenced around the existing _resolve_generation_engine and the blocks at the
other handler locations) to call this helper with (data, profile), first resolve
the engine via _resolve_generation_engine, and if data.model_size is missing use
the helper-provided fallback for that engine so TADA receives a valid size when
auto-selected. Ensure the helper is referenced by the functions handling
generation requests so both handlers reuse the same fallback logic.

In `@backend/services/profiles.py`:
- Around line 105-110: The designed-profile branch currently only validates
design_prompt and allows creating a designed profile bound to any backend later;
update the validation in the profiles.py logic handling voice_type == "designed"
(and the similar branch around lines 135-139) to require a non-empty
default_engine and to reject creation/update if default_engine is missing or
does not match the engine/backend being requested; also keep rejecting
preset_engine or preset_voice_id for designed profiles and ensure
create_voice_prompt_for_profile() will only receive designed profiles when
default_engine matches the target engine. Ensure you reference and validate the
default_engine field against the current requested engine parameter and return
an error string like the existing checks when mismatches occur.
- Around line 72-83: The helper _get_preset_voice_ids currently returns an empty
set for unknown engines which silently allows invalid "preset" profiles; change
_get_preset_voice_ids to raise a clear exception (e.g., ValueError("unsupported
preset engine: {engine}")) when the engine is not one of the known preset
backends instead of returning set(), and update the code paths that call
_get_preset_voice_ids (the places that currently receive its return and treat an
empty set as "skip validation") to not treat an exception as a skip but to
propagate or surface the error so profile creation/validation fails for
unsupported engines and invalid preset_voice_id values. Ensure references to the
function name _get_preset_voice_ids and any local variable like preset_ids /
voice_type are used to locate and change the behavior.
- Around line 369-383: Normalize the incoming default_engine value (convert
empty string "" to None) before calling _validate_profile_fields so validation
uses the same normalized value later used when updating preset profiles;
specifically update the logic around voice_type, preset_engine, preset_voice_id,
design_prompt and default_engine so default_engine = data.default_engine if
data.default_engine is not None else getattr(profile, "default_engine", None) is
normalized (treat "" as None) prior to invoking _validate_profile_fields(...) to
prevent an empty-string default_engine from passing validation and later
clearing a locked preset profile engine.

---

Outside diff comments:
In `@backend/routes/profiles.py`:
- Around line 1-17: The update_profile_effects function calls datetime.utcnow()
but datetime isn't imported, causing a NameError; add the missing import by
adding "from datetime import datetime" to the module imports at the top so
update_profile_effects can reference datetime.utcnow() (look for the
update_profile_effects function and the top import block to place the import).

---

Duplicate comments:
In `@app/src/components/Generation/GenerationForm.tsx`:
- Around line 30-35: Update getEngineSelectValue to stop unconditionally mapping
'tada' to 'tada:1B' — instead accept an optional preferredTadaSize and/or
profileLanguage and use those to pick the TADA size: if preferredTadaSize is
provided return `tada:{preferredTadaSize}`, else if profileLanguage exists and
!== 'en' return 'tada:3B', else fall back to 'tada:1B' (or preserve the bare
'tada' if you prefer to persist the profile value). Apply the same change to the
other helper instance mentioned (the second getEngineSelectValue occurrence) so
selecting a non-English TADA profile no longer resets language to English.

In `@app/src/components/VoiceProfiles/ProfileForm.tsx`:
- Around line 367-374: The effect clearing defaultEngine to '' prevents
selection of an incompatible engine but the save path collapses '' to undefined
so the backend retains the old default_engine; update the save/edit payload
builder (the function that constructs the edit payload—e.g., the
submit/handleSave or updateVoiceProfile code) to explicitly send a null (or an
explicit empty value) when defaultEngine === '' (for example set
payload.default_engine = defaultEngine === '' ? null : defaultEngine) so the
backend will clear the stored value; apply the same change for the other save
path referenced around the defaultEngine handling at lines 476-483.

In `@backend/routes/generations.py`:
- Around line 43-46: The current except ValueError handlers around
profiles.validate_profile_engine(profile, engine) catch the ValueError and raise
an HTTPException but drop the original exception context; update both handlers
(the one at the validate_profile_engine call and the similar block at lines
around 243-246) to re-raise the HTTPException using "raise HTTPException(... )
from e" so the original ValueError is preserved as the __cause__ for better
debugging while keeping the same status_code and detail.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@app/src/components/Generation/FloatingGenerateBox.tsx`:
- Line 411: The floating flow removed the selectedProfile prop from
EngineModelSelector causing profile-aware engine filtering and auto-correction
to be skipped; restore passing selectedProfile from the surrounding form/state
into EngineModelSelector (same prop used by GenerationForm) so
EngineModelSelector receives selectedProfile and resumes compatibility checks
and auto-corrections for engine/profile combinations.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@app/src/components/VoiceProfiles/ProfileCard.tsx`:
- Around line 20-24: ENGINE_DISPLAY_NAMES in ProfileCard.tsx uses "CustomVoice"
for the key qwen_custom_voice which mismatches the "Qwen CustomVoice" label
rendered by ProfileList.tsx; fix by centralizing the engine display names
(exporting/importing a shared map) or change
ENGINE_DISPLAY_NAMES['qwen_custom_voice'] to "Qwen CustomVoice" so both
ProfileCard and ProfileList use the identical label (update the constant named
ENGINE_DISPLAY_NAMES or replace its usage with the shared map).

In `@backend/backends/qwen_custom_voice_backend.py`:
- Around line 188-193: The seeded RNG calls in _generate_sync currently use
torch.manual_seed and torch.cuda.manual_seed which mutate global PyTorch state
and cause cross-request interference; replace this by either (preferred)
creating and using a per-request torch.Generator (pass it into the model/sample
calls if Qwen API accepts a generator) or, if the API doesn't support a
Generator, wrap the seed section in a backend-level lock or save the global RNG
state with torch.get_rng_state()/torch.cuda.get_rng_state_all(), set the seeds,
run generation, then restore the saved RNG states using
torch.set_rng_state()/torch.cuda.set_rng_state_all() to avoid leaking the seed
to other threads. Ensure changes target the _generate_sync function and related
generation calls that currently rely on
torch.manual_seed/torch.cuda.manual_seed.

In `@backend/routes/generations.py`:
- Around line 23-24: The resolver _resolve_generation_engine is never reaching
profile defaults because models.GenerationRequest currently defaults engine to
"qwen"; either make the request fields nullable (change GenerationRequest.engine
and .model_size to Optional[str] with no literal default) or change the resolver
to detect whether the caller omitted the field by checking data.model_fields_set
(or equivalent) before using data.engine; update _resolve_generation_engine to
use: if "engine" in data.model_fields_set then use data.engine else fall through
to getattr(profile, "default_engine", None) or getattr(profile, "preset_engine",
None) or "qwen" (and apply the same pattern for model_size defaults), so
profile-aware auto-selection and engine-specific size defaults are respected.

---

Outside diff comments:
In `@backend/backends/__init__.py`:
- Around line 418-423: The branch that calls backend._is_model_cached() can
raise ValueError from QwenCustomVoiceBackend._get_model_path() for invalid sizes
(e.g., "3B"), so wrap the call in a try/except or validate the engine/model_size
pair first: catch ValueError around backend._is_model_cached(model_size) (or
pre-check that engine == "qwen_custom_voice" and model_size is one of the
supported sizes) and convert the error into the same HTTPException used for
missing models (status_code=400, descriptive detail) so invalid sizes return 400
instead of bubbling up as 500.

---

Duplicate comments:
In `@app/src/components/Generation/FloatingGenerateBox.tsx`:
- Line 411: The EngineModelSelector in FloatingGenerateBox can let the form
switch to engines incompatible with the current selectedProfile, causing backend
400s via profiles.validate_profile_engine; update FloatingGenerateBox to check
compatibility whenever EngineModelSelector changes or when selectedProfile
changes (use the form state and selectedProfile prop), and if the new
engine/profile pair is incompatible either auto-clear selectedProfile (or
auto-switch the engine to a compatible default) or disable the submit button and
prevent selection of incompatible engines when showVoiceSelector is false;
reference the EngineModelSelector component, the form state fields (engine,
selectedProfile), and the profiles.validate_profile_engine check so you enforce
the guard in the selection handler and on submit.

In `@app/src/components/Generation/GenerationForm.tsx`:
- Around line 30-35: The helper getEngineSelectValue currently normalizes 'tada'
to 'tada:1B' unconditionally, which can override non-English profile language;
change getEngineSelectValue(engine: string) to getEngineSelectValue(engine:
string, profileLanguage?: string) and only map bare 'tada' -> 'tada:1B' (and
similarly for 'qwen'/'qwen_custom_voice' if needed) when profileLanguage
indicates English (e.g., 'en'); update all callers (the engine selection usage
around the existing engine mapping/selection code that currently calls
getEngineSelectValue, including where selectedProfile.language is in scope) to
pass selectedProfile.language, and leave the function to return the original
engine unchanged for non-English profiles.

In `@backend/database/migrations.py`:
- Around line 197-198: The code currently falls back to calling p.resolve() when
a rebased path (computed relative to get_data_dir()) doesn't exist, which makes
behavior depend on the process CWD; remove that CWD fallback by deleting the
p.resolve() branch and instead treat a missing rebased path as an error (e.g.,
raise FileNotFoundError or return an explicit None) so rows are not silently
rewritten to files under CWD; update the logic around get_data_dir() and the
rebasing code that invokes p.resolve() to either raise a clear error with
context or return the missing-path marker instead of resolving against CWD.